using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml;
using System.Text;
using System.Globalization;
using System.Reflection;
using System.Xml.Linq;
using System.Text.RegularExpressions;

namespace AutoTestReporter
{
    /// <summary>
    /// 测试报告生成器 - 自动根据TRX文件生成单元测试报告
    /// </summary>
    public class TestReportGenerator
    {
        /// <summary>
        /// 解析TRX文件并生成Markdown格式的测试报告
        /// </summary>
        /// <param name="trxFilePath">TRX文件路径</param>
        /// <param name="outputDirectory">输出目录</param>
        /// <returns>生成的报告文件路径</returns>
        public string GenerateReportFromTrx(string trxFilePath, string outputDirectory)
        {
            if (!File.Exists(trxFilePath))
            {
                throw new FileNotFoundException($"TRX文件不存在: {trxFilePath}");
            }

            // 解析TRX文件
            var testResults = ParseTrxFile(trxFilePath);
            
            // 生成报告文件名
            var reportFileName = $"单元测试报告_{DateTime.Now:yyyy-MM-dd_HHmm}.md";
            var reportFilePath = Path.Combine(outputDirectory, reportFileName);
            
            // 生成报告内容
            var reportContent = GenerateMarkdownReport(testResults);
            
            // 确保输出目录存在
            Directory.CreateDirectory(outputDirectory);
            
            // 写入报告文件
            File.WriteAllText(reportFilePath, reportContent);
            
            return reportFilePath;
        }

        /// <summary>
        /// 解析TRX文件并提取测试结果信息
        /// </summary>
        private TestResultsData ParseTrxFile(string trxFilePath)
        {
            var testResults = new TestResultsData();
            var doc = new XmlDocument();
            doc.Load(trxFilePath);

            // 创建XML命名空间管理器
            var nsManager = new XmlNamespaceManager(doc.NameTable);
            nsManager.AddNamespace("ns", "http://microsoft.com/schemas/VisualStudio/TeamTest/2010");

            // 获取测试运行信息
            var testRunNode = doc.SelectSingleNode("//ns:TestRun", nsManager);
            if (testRunNode?.Attributes != null)
            {
                testResults.RunId = testRunNode.Attributes["id"]?.Value ?? "Unknown";
                testResults.RunName = testRunNode.Attributes["name"]?.Value ?? "Unknown";
            }

            // 获取时间信息
            var timesNode = doc.SelectSingleNode("//ns:Times", nsManager);
            if (timesNode?.Attributes != null)
            {
                testResults.StartTime = timesNode.Attributes["start"]?.Value ?? "Unknown";
                testResults.FinishTime = timesNode.Attributes["finish"]?.Value ?? "Unknown";
            }

            // 获取测试结果
            var resultNodes = doc.SelectNodes("//ns:UnitTestResult", nsManager);
            if (resultNodes != null)
            {
                foreach (XmlNode resultNode in resultNodes)
                {
                    var testResult = new TestResult
                    {
                        TestName = resultNode.Attributes?["testName"]?.Value ?? "Unknown",
                        Outcome = resultNode.Attributes?["outcome"]?.Value ?? "Unknown",
                        Duration = resultNode.Attributes?["duration"]?.Value ?? "Unknown",
                        StartTime = resultNode.Attributes?["startTime"]?.Value ?? "Unknown",
                        EndTime = resultNode.Attributes?["endTime"]?.Value ?? "Unknown"
                    };

                    testResults.TestResults.Add(testResult);
                }
            }

            // 统计测试结果
            testResults.TotalTests = testResults.TestResults.Count;
            testResults.PassedTests = testResults.TestResults.Count(r => r.Outcome.Equals("Passed", StringComparison.OrdinalIgnoreCase));
            testResults.FailedTests = testResults.TestResults.Count(r => r.Outcome.Equals("Failed", StringComparison.OrdinalIgnoreCase));
            testResults.SkippedTests = testResults.TestResults.Count(r => r.Outcome.Equals("NotExecuted", StringComparison.OrdinalIgnoreCase));

            return testResults;
        }

        /// <summary>
        /// 生成Markdown格式的测试报告
        /// </summary>
        private string GenerateMarkdownReport(TestResultsData testResults)
        {
            var report = new List<string>();
            
            // 报告标题
            report.Add("# 单元测试报告\n");
            
            // 测试执行概览
            report.Add("## 测试执行概览\n");
            report.Add($"- **测试执行时间**: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
            report.Add($"- **测试运行ID**: {testResults.RunId}");
            report.Add($"- **测试运行名称**: {testResults.RunName}");
            report.Add($"- **开始时间**: {testResults.StartTime}");
            report.Add($"- **结束时间**: {testResults.FinishTime}");
            report.Add($"- **测试总数**: {testResults.TotalTests}");
            report.Add($"- **通过测试**: {testResults.PassedTests}");
            report.Add($"- **失败测试**: {testResults.FailedTests}");
            report.Add($"- **跳过测试**: {testResults.SkippedTests}");
            report.Add($"- **通过率**: {(testResults.TotalTests > 0 ? (testResults.PassedTests * 100.0 / testResults.TotalTests).ToString("F1") : "0")}%\n");

            // 测试分类统计
            report.Add("## 测试分类统计\n");
            
            var testGroups = testResults.TestResults
                .GroupBy(r => GetTestClassName(r.TestName))
                .OrderBy(g => g.Key);

            var tableHeader = "| 测试类 | 测试数量 | 通过数量 | 失败数量 | 跳过数量 | 通过率 |";
            var tableSeparator = "|---------|---------|---------|---------|---------|--------|";
            
            report.Add(tableHeader);
            report.Add(tableSeparator);

            foreach (var group in testGroups)
            {
                var passed = group.Count(r => r.Outcome.Equals("Passed", StringComparison.OrdinalIgnoreCase));
                var failed = group.Count(r => r.Outcome.Equals("Failed", StringComparison.OrdinalIgnoreCase));
                var skipped = group.Count(r => r.Outcome.Equals("NotExecuted", StringComparison.OrdinalIgnoreCase));
                var total = group.Count();
                var passRate = total > 0 ? (passed * 100.0 / total).ToString("F1") : "0.0";
                
                report.Add($"| {group.Key} | {total} | {passed} | {failed} | {skipped} | {passRate}% |");
            }

            // 总计行
            var totalPassRate = testResults.TotalTests > 0 ? (testResults.PassedTests * 100.0 / testResults.TotalTests).ToString("F1") : "0.0";
            report.Add($"| **总计** | **{testResults.TotalTests}** | **{testResults.PassedTests}** | **{testResults.FailedTests}** | **{testResults.SkippedTests}** | **{totalPassRate}%** |\n");

            // 详细测试结果
            report.Add("## 详细测试结果\n");
            
            // 按测试类分组
            foreach (var group in testGroups)
            {
                report.Add($"### {group.Key} 测试类\n");
                
                // 创建表格 - 简化列宽，避免内容过长导致格式混乱
                report.Add("| 结果 | 耗时(ms) | 方法名 | 描述 | 场景 | 预期结果 |");
                report.Add("|------|----------|--------|------|------|----------|");
                
                // 每个测试方法一行
                foreach (var testResult in group.OrderBy(r => r.TestName))
                {
                    var statusIcon = testResult.Outcome.Equals("Passed", StringComparison.OrdinalIgnoreCase) ? "✅" : 
                                   testResult.Outcome.Equals("Failed", StringComparison.OrdinalIgnoreCase) ? "❌" : "⚠️";
                    var methodName = GetTestMethodName(testResult.TestName);
                    var testedFunctionName = GetTestedFunctionName(methodName);
                    var description = GetTestDescription(testResult.TestName);
                    var scenario = GetTestScenario(testResult.TestName);
                    var expectedResult = GetExpectedResult(testResult.TestName);
                    
                    // 转换为毫秒 - 只保留测试耗时
                    var durationMs = TimeSpan.TryParse(testResult.Duration, out var durationTimeSpan) ? 
                        durationTimeSpan.TotalMilliseconds.ToString("F1") : "N/A";
                    
                    // 移除换行符，确保表格格式正确
                    var cleanTestedFunctionName = testedFunctionName.Replace("\n", " ").Replace("\r", " ").Trim();
                    var cleanDescription = description.Replace("\n", " ").Replace("\r", " ").Trim();
                    var cleanScenario = scenario.Replace("\n", " ").Replace("\r", " ").Trim();
                    var cleanExpectedResult = expectedResult.Replace("\n", " ").Replace("\r", " ").Trim();
                    
                    // 简化内容，避免内容过长
                    var shortTestedFunctionName = cleanTestedFunctionName.Length > 80 ? cleanTestedFunctionName.Substring(0, 77) + "..." : cleanTestedFunctionName;
                    var shortDescription = cleanDescription.Length > 50 ? cleanDescription.Substring(0, 47) + "..." : cleanDescription;
                    var shortScenario = cleanScenario.Length > 50 ? cleanScenario.Substring(0, 47) + "..." : cleanScenario;
                    var shortExpectedResult = cleanExpectedResult.Length > 50 ? cleanExpectedResult.Substring(0, 47) + "..." : cleanExpectedResult;
                    
                    report.Add($"| {statusIcon} | {durationMs} | {shortTestedFunctionName} | {shortDescription} | {shortScenario} | {shortExpectedResult} |");
                }
                report.Add("\n");
            }

            // 测试质量评估
            report.Add("## 测试质量评估\n");
            
            if (testResults.FailedTests == 0 && testResults.SkippedTests == 0)
            {
                report.Add("✅ **测试覆盖范围**: 所有测试用例均通过执行\n");
                report.Add("✅ **测试设计质量**: 测试用例设计合理，覆盖主要业务场景\n");
                report.Add("✅ **代码质量**: 测试代码结构清晰，遵循最佳实践\n");
            }
            else if (testResults.FailedTests > 0)
            {
                report.Add("⚠️ **测试覆盖范围**: 存在失败的测试用例，需要进一步分析");
                report.Add("⚠️ **测试设计质量**: 部分测试用例执行失败，需要检查测试逻辑");
                report.Add("⚠️ **代码质量**: 存在需要修复的问题\n");
            }

            // 测试结论
            report.Add("## 测试结论\n");
            
            if (testResults.FailedTests == 0 && testResults.SkippedTests == 0)
            {
                report.Add("本次单元测试执行结果**完全通过**，所有测试用例均成功执行。\n");
                report.Add("测试结果表明，系统功能稳定可靠，具备生产环境部署的条件。\n");
            }
            else if (testResults.FailedTests > 0)
            {
                report.Add($"本次单元测试执行结果**存在{testResults.FailedTests}个失败的测试用例**。\n");
                report.Add("需要进一步分析失败原因并进行修复。\n");
            }
            else
            {
                report.Add($"本次单元测试执行结果**通过{testResults.PassedTests}个测试用例，跳过{testResults.SkippedTests}个测试用例**。\n");
                report.Add("测试结果表明系统基本功能正常，但存在跳过的测试用例需要关注。\n");
            }

            // 报告页脚
            report.Add("---\n");
            report.Add($"**报告生成时间**: {DateTime.Now:yyyy-MM-dd HH:mm:ss}\n");
            report.Add("**报告生成工具**: TestReportGenerator\n");
            report.Add("**测试框架**: xUnit\n");
            report.Add("**测试运行器**: Visual Studio Test Runner\n");
            
            // 添加时间差分析附录
            report.Add("\n---\n\n");
            report.Add("# 附录\n");
            report.Add("---\n");
            report.Add("## 一：时间差与测试耗时不匹配分析\n");
            report.Add("### 问题描述\n");
            report.Add("测试报告中存在\"测试耗时(ms)\"和\"时间差(ms)\"两个时间指标，两者数值存在显著差异。\n");
            report.Add("### 技术原因分析\n");
            report.Add("#### 1. 数据来源不同\n");
            report.Add("- **测试耗时(ms)**：来自TRX文件中的`duration`属性，由测试框架内部计时器记录\n");
            report.Add("- **时间差(ms)**：通过计算`endTime - startTime`得到，基于系统时钟的精确时间戳\n");
            report.Add("#### 2. 计时机制差异\n");
            report.Add("- **时间差**：反映测试方法本身的执行时间，精度达到微秒级别（7位小数）\n");
            report.Add("- **测试耗时**：包含测试框架的完整执行周期，可能包括：\n");
            report.Add("  - 测试方法的发现和加载\n");
            report.Add("  - 依赖注入容器的初始化\n");
            report.Add("  - 测试夹具的创建和销毁\n");
            report.Add("  - 测试运行器的调度开销\n");
            report.Add("#### 3. 典型差异示例");
            report.Add("- **GetActiveUserIds测试**：\n");
            report.Add("  - 测试耗时：15.0408毫秒\n");
            report.Add("  - 时间差：0.0246毫秒\n");
            report.Add("  - 差异：测试耗时是时间差的611倍\n");
            report.Add("- **Logout测试**：\n");
            report.Add("  - 测试耗时：47.8555毫秒\n");
            report.Add("  - 时间差：0.0006毫秒\n");
            report.Add("  - 差异：测试耗时是时间差的79,767倍\n");
            report.Add("### 使用建议\n");
            report.Add("- **分析测试方法性能**：使用**时间差**，更准确地反映测试代码执行效率\n");
            report.Add("- **分析测试框架开销**：使用**测试耗时**，了解测试框架的整体执行时间\n");
            report.Add("- **性能优化重点**：关注实际时间差较大的测试方法，进行代码优化\n");
            report.Add("### 结论\n");
            report.Add("时间差与耗时不匹配是测试框架的正常现象，反映了不同层次的计时机制。这种差异在单元测试中常见，特别是当测试框架有较多额外开销时。\n");

            return string.Join("\n", report);
        }

        /// <summary>
        /// 从测试名称中提取类名
        /// </summary>
        private string GetTestClassName(string testName)
        {
            var parts = testName.Split('.');
            
            // 测试名称格式：Application.Tests.SessionManagerServiceTests.CreateSession_WhenUserNotLoggedIn_ShouldCreateSession
            // 我们需要提取被测试的类名，即第3部分（SessionManagerServiceTests）
            if (parts.Length >= 3)
            {
                // 提取类名并去掉可能的"Tests"后缀
                var className = parts[2];
                if (className.EndsWith("Tests"))
                {
                    className = className.Substring(0, className.Length - 5);
                }
                return className;
            }
            
            return "Unknown";
        }

        /// <summary>
        /// 从测试名称中提取完整方法名
        /// </summary>
        private string GetTestMethodName(string testName)
        {
            var parts = testName.Split('.');
            
            // 测试名称格式：Application.Test.PermissionServiceTests.GetAllAsync_WhenPermissionsExist_ShouldReturnAllPermissions
            // 我们需要提取测试方法名，即最后一部分（GetAllAsync_WhenPermissionsExist_ShouldReturnAllPermissions）
            if (parts.Length >= 3)
            {
                return parts[parts.Length - 1];
            }
            
            return "Unknown";
        }

        /// <summary>
        /// 从XML文档中获取测试方法的注释信息
        /// </summary>
        private (string description, string scenario, string expectedResult) GetTestInfoFromXmlComments(string testName)
        {
            try
            {
                var methodName = GetTestMethodName(testName);
                var xmlDocPath = Path.Combine(Directory.GetCurrentDirectory(), "..", "Application.Test", "bin", "Debug", "net9.0", "Application.Test.xml");
                
                if (!File.Exists(xmlDocPath))
                {
                    // 如果XML文档不存在，返回基于方法名的默认值
                    return GetDefaultTestInfo(methodName);
                }

                var xmlDoc = XDocument.Load(xmlDocPath);
                
                // 查找对应的测试方法注释
                var member = xmlDoc.Descendants("member")
                    .FirstOrDefault(m => m.Attribute("name")?.Value?.Contains($".{methodName}") == true);

                if (member == null)
                {
                    return GetDefaultTestInfo(methodName);
                }

                // 解析注释内容 - 主要从summary中提取信息
                var summary = member.Element("summary")?.Value?.Trim() ?? "功能验证测试";
                
                // 使用改进的解析逻辑，支持统一注释格式
                return ParseUnifiedXmlComments(summary, methodName);
            }
            catch (Exception ex)
            {
                // 如果解析失败，返回默认值
                Console.WriteLine($"XML注释解析失败: {ex.Message}");
                var methodName = GetTestMethodName(testName);
                return GetDefaultTestInfo(methodName);
            }
        }

        /// <summary>
        /// 解析统一格式的XML注释
        /// </summary>
        private (string description, string scenario, string expectedResult) ParseUnifiedXmlComments(string summary, string methodName)
        {
            if (string.IsNullOrWhiteSpace(summary))
            {
                return GetDefaultTestInfo(methodName);
            }

            // 检查是否为统一格式（包含"描述："、"场景："、"预期结果："）
            if (summary.Contains("描述：") && summary.Contains("场景：") && summary.Contains("预期结果："))
            {
                return ParseStandardUnifiedFormat(summary);
            }
            
            // 检查是否为旧格式（包含"验证："）
            if (summary.Contains("验证："))
            {
                return ParseLegacyFormat(summary);
            }
            
            // 如果都不是，使用基于方法名的智能解析
            return ParseSmartFormat(summary, methodName);
        }

        /// <summary>
        /// 解析标准统一格式的注释
        /// </summary>
        private (string description, string scenario, string expectedResult) ParseStandardUnifiedFormat(string summary)
        {
            var lines = summary.Split('\n').Select(line => line.Trim()).Where(line => !string.IsNullOrWhiteSpace(line)).ToArray();
            
            string description = "功能验证测试";
            string scenario = "正常功能测试场景";
            string expectedResult = "- 功能正常执行\n- 返回预期结果";
            
            foreach (var line in lines)
            {
                if (line.StartsWith("描述："))
                {
                    description = line.Substring(3).Trim();
                }
                else if (line.StartsWith("场景："))
                {
                    scenario = line.Substring(3).Trim();
                }
                else if (line.StartsWith("预期结果："))
                {
                    expectedResult = line.Substring(5).Trim();
                }
            }
            
            return (description, scenario, expectedResult);
        }

        /// <summary>
        /// 解析旧格式的注释
        /// </summary>
        private (string description, string scenario, string expectedResult) ParseLegacyFormat(string summary)
        {
            var lines = summary.Split('\n').Select(line => line.Trim()).Where(line => !string.IsNullOrWhiteSpace(line)).ToArray();
            
            string description = lines.Length > 0 ? lines[0] : "功能验证测试";
            string scenario = "正常功能测试场景";
            string expectedResult = "- 功能正常执行\n- 返回预期结果";
            
            // 从第二行开始查找验证信息
            for (int i = 1; i < lines.Length; i++)
            {
                if (lines[i].StartsWith("验证："))
                {
                    scenario = $"验证：{lines[i].Substring(3).Trim()}";
                    expectedResult = ExtractExpectedResultFromSummary(lines[i].Substring(3).Trim());
                    break;
                }
            }
            
            return (description, scenario, expectedResult);
        }

        /// <summary>
        /// 基于方法名的智能解析
        /// </summary>
        private (string description, string scenario, string expectedResult) ParseSmartFormat(string summary, string methodName)
        {
            var description = summary;
            var scenario = ExtractScenarioFromMethodName(methodName);
            var expectedResult = ExtractExpectedResultFromMethodName(methodName);
            
            return (description, scenario, expectedResult);
        }

        /// <summary>
        /// 从方法名中提取测试场景
        /// </summary>
        private string ExtractScenarioFromMethodName(string methodName)
        {
            if (methodName.Contains("WhenUserNotLoggedIn"))
            {
                return "当用户未登录时";
            }
            else if (methodName.Contains("WhenUserAlreadyLoggedIn") || methodName.Contains("WhenUserIsLoggedIn"))
            {
                return "当用户已登录时";
            }
            else if (methodName.Contains("WhenSessionExists"))
            {
                return "当会话存在时";
            }
            else if (methodName.Contains("WhenSessionNotExists"))
            {
                return "当会话不存在时";
            }
            else if (methodName.Contains("WithValidCredentials"))
            {
                return "使用有效凭据";
            }
            else if (methodName.Contains("WithInvalidCredentials"))
            {
                return "使用无效凭据";
            }
            else if (methodName.Contains("WithInvalidSessionId") || methodName.Contains("WithInvalidUserId"))
            {
                return "使用无效参数";
            }
            else if (methodName.Contains("WhenNoSessionsExist"))
            {
                return "当没有活跃会话时";
            }
            else if (methodName.Contains("ConcurrentAccess"))
            {
                return "在多线程并发访问时";
            }
            
            return "正常功能测试场景";
        }

        /// <summary>
        /// 从方法名中提取预期结果
        /// </summary>
        private string ExtractExpectedResultFromMethodName(string methodName)
        {
            if (methodName.Contains("ShouldReturnTrue") || methodName.Contains("ShouldCreateSession") || 
                methodName.Contains("ShouldRemoveSession") || methodName.Contains("ShouldGenerateUniqueId") ||
                methodName.Contains("ShouldReturnAllActiveUserIds"))
            {
                return "操作成功执行并返回正确结果";
            }
            else if (methodName.Contains("ShouldReturnFalse") || methodName.Contains("ShouldReturnEmptyList"))
            {
                return "操作执行失败或返回空结果";
            }
            else if (methodName.Contains("ShouldReturnNull"))
            {
                return "操作执行失败并返回null";
            }
            else if (methodName.Contains("ShouldBeThreadSafe"))
            {
                return "系统应该保持线程安全";
            }
            
            return "- 功能正常执行\n- 返回预期结果";
        }

        /// <summary>
        /// 获取基于方法名的默认测试信息
        /// </summary>
        private (string description, string scenario, string expectedResult) GetDefaultTestInfo(string methodName)
        {
            var description = $"测试{GetTestedFunctionName(methodName)}功能";
            var scenario = ExtractScenarioFromMethodName(methodName);
            var expectedResult = ExtractExpectedResultFromMethodName(methodName);
            
            return (description, scenario, expectedResult);
        }

        /// <summary>
        /// 从summary中提取测试场景
        /// </summary>
        private string ExtractScenarioFromSummary(string summary)
        {
            if (string.IsNullOrWhiteSpace(summary))
                return "正常功能测试场景";

            // 改进的场景提取逻辑
            if (summary.Contains("验证"))
            {
                var parts = summary.Split(new[] { "验证：", "验证" }, StringSplitOptions.RemoveEmptyEntries);
                if (parts.Length > 1)
                {
                    return $"验证：{parts.Last().Trim()}";
                }
            }
            
            // 如果包含换行符，提取第一行作为场景
            if (summary.Contains("\n"))
            {
                var firstLine = summary.Split('\n')[0].Trim();
                return firstLine;
            }
            
            // 默认返回整个summary作为场景
            return summary;
        }

        /// <summary>
        /// 从summary中提取预期结果
        /// </summary>
        private string ExtractExpectedResultFromSummary(string summary)
        {
            if (string.IsNullOrWhiteSpace(summary))
                return "- 功能正常执行\n- 返回预期结果";

            // 改进的预期结果提取逻辑
            if (summary.Contains("成功") && summary.Contains("登录"))
            {
                return "- 登录操作成功执行\n- 返回正确的用户信息\n- 生成有效的会话ID";
            }
            else if (summary.Contains("成功") && summary.Contains("登出"))
            {
                return "- 登出操作成功执行\n- 正确移除用户会话\n- 更新认证状态";
            }
            else if (summary.Contains("成功") && summary.Contains("创建"))
            {
                return "- 创建操作成功执行\n- 返回正确结果\n- 记录用户登录状态";
            }
            else if (summary.Contains("成功") && summary.Contains("移除"))
            {
                return "- 移除操作成功执行\n- 返回正确结果\n- 更新用户登录状态";
            }
            else if (summary.Contains("成功") && summary.Contains("获取"))
            {
                return "- 获取操作成功执行\n- 返回正确的结果列表\n- 数据完整准确";
            }
            else if (summary.Contains("成功"))
            {
                return "- 操作成功执行\n- 返回正确结果";
            }
            else if (summary.Contains("失败") || summary.Contains("错误"))
            {
                return "- 操作执行失败\n- 返回错误信息";
            }
            else if (summary.Contains("异常"))
            {
                return "- 操作抛出异常\n- 异常处理正确";
            }
            else if (summary.Contains("返回false"))
            {
                return "- 操作执行失败\n- 返回false";
            }
            else if (summary.Contains("返回null"))
            {
                return "- 操作执行失败\n- 返回null";
            }
            else if (summary.Contains("返回空"))
            {
                return "- 操作成功执行\n- 返回空列表";
            }
            
            // 根据测试方法名推断预期结果
            var methodName = summary.Contains("Async") ? "异步操作" : "同步操作";
            return $"- {methodName}正常执行\n- 返回预期结果";
        }

        /// <summary>
        /// 从测试方法名中提取被测函数名，并在英文函数名后添加中文注释
        /// </summary>
        private string GetTestedFunctionName(string testMethodName)
        {
            // 测试方法名通常遵循模式：被测函数名_测试场景_预期结果
            // 提取第一个下划线前的部分作为被测函数名
            var underscoreIndex = testMethodName.IndexOf('_');
            string functionName;
            
            if (underscoreIndex > 0)
            {
                functionName = testMethodName.Substring(0, underscoreIndex);
            }
            else if (testMethodName.EndsWith("Async"))
            {
                // 如果没有下划线，尝试提取Async后缀前的部分
                functionName = testMethodName.Substring(0, testMethodName.Length - 5);
            }
            else
            {
                // 如果都不符合，返回完整方法名
                functionName = testMethodName;
            }
            
            // 在英文函数名后添加中文注释
            return functionName + GetChineseComment(functionName);
        }

        /// <summary>
        /// 根据英文函数名获取对应的中文注释
        /// 通过解析XML文档文件获取真实的函数注释
        /// </summary>
        private string GetChineseComment(string functionName)
        {
            try
            {
                // 查找XML文档文件路径
                var xmlDocPath = FindXmlDocumentationFile();
                if (string.IsNullOrEmpty(xmlDocPath) || !File.Exists(xmlDocPath))
                {
                    return GetFallbackComment(functionName);
                }

                // 加载XML文档
                var xmlDoc = new XmlDocument();
                xmlDoc.Load(xmlDocPath);

                // 查找对应的函数注释
                var comment = FindFunctionComment(xmlDoc, functionName);
                if (!string.IsNullOrEmpty(comment))
                {
                    return comment;
                }

                // 如果找不到，尝试查找Async版本
                if (functionName.EndsWith("Async"))
                {
                    var baseName = functionName.Substring(0, functionName.Length - 5);
                    comment = FindFunctionComment(xmlDoc, baseName);
                    if (!string.IsNullOrEmpty(comment))
                    {
                        return comment + "异步";
                    }
                }

                return GetFallbackComment(functionName);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"获取函数 {functionName} 的注释时出错: {ex.Message}");
                return GetFallbackComment(functionName);
            }
        }

        /// <summary>
        /// 查找XML文档文件路径
        /// </summary>
        private string FindXmlDocumentationFile()
        {
            // 尝试在多个可能的位置查找XML文档文件
            var possiblePaths = new[]
            {
                Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Application.Service.xml"),
                Path.Combine(Directory.GetCurrentDirectory(), "Application.Service.xml"),
                Path.Combine(Directory.GetCurrentDirectory(), "..", "Application.Service", "Application.Service.xml"),
                Path.Combine(Directory.GetCurrentDirectory(), "..", "Application.Service", "bin", "Debug", "net9.0", "Application.Service.xml"),
                Path.Combine(Directory.GetCurrentDirectory(), "..", "Application.Service", "bin", "Release", "net9.0", "Application.Service.xml")
            };

            foreach (var path in possiblePaths)
            {
                if (File.Exists(path))
                {
                    return path;
                }
            }

            return null;
        }

        /// <summary>
        /// 在XML文档中查找函数注释
        /// </summary>
        private string FindFunctionComment(XmlDocument xmlDoc, string functionName)
        {
            try
            {
                // 构建XPath查询来查找函数注释
                var xpathQueries = new[]
                {
                    $"//member[contains(@name, 'M:Application.Service.Auth.AuthService.{functionName}')]//summary",
                    $"//member[contains(@name, 'M:Application.Service.Auth.SessionManagerService.{functionName}')]//summary",
                    $"//member[contains(@name, 'M:Application.Service.Users.UserService.{functionName}')]//summary",
                    $"//member[contains(@name, 'M:Application.Service.Permissions.PermissionService.{functionName}')]//summary",
                    $"//member[contains(@name, 'M:Application.Service.System.SystemService.{functionName}')]//summary",
                    $"//member[contains(@name, 'M:Application.Service.LogCache.LogCacheService.{functionName}')]//summary"
                };

                foreach (var xpath in xpathQueries)
                {
                    var node = xmlDoc.SelectSingleNode(xpath);
                    if (node != null)
                    {
                        var comment = ExtractCommentFromXml(node.InnerXml);
                        if (!string.IsNullOrEmpty(comment))
                        {
                            return comment;
                        }
                    }
                }

                return null;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"在XML文档中查找函数 {functionName} 的注释时出错: {ex.Message}");
                return null;
            }
        }

        /// <summary>
        /// 从XML节点内容中提取注释
        /// </summary>
        private string ExtractCommentFromXml(string xmlContent)
        {
            if (string.IsNullOrEmpty(xmlContent))
                return null;

            // 移除XML标签和多余的空格
            var comment = xmlContent
                .Replace("<summary>", "")
                .Replace("</summary>", "")
                .Replace("<para>", "")
                .Replace("</para>", "")
                .Replace("<list>", "")
                .Replace("</list>", "")
                .Replace("<item>", "")
                .Replace("</item>", "")
                .Replace("<description>", "")
                .Replace("</description>", "")
                .Trim();

            // 提取第一句话或主要描述
             var firstSentence = comment.Split('.')[0].Trim();
             if (!string.IsNullOrEmpty(firstSentence))
             {
                 // 移除括号中的内容，保留主要描述
                 var cleanComment = System.Text.RegularExpressions.Regex.Replace(firstSentence, @"\(.*?\)", "").Trim();
                 
                 // 如果注释不为空，添加括号格式
                 if (!string.IsNullOrEmpty(cleanComment))
                 {
                     return $"({cleanComment})";
                 }
             }

             return null;
         }

        /// <summary>
        /// 获取备用注释（当无法从XML文档获取时使用）
        /// </summary>
        private string GetFallbackComment(string functionName)
        {
            // 常见函数名与中文注释的映射（备用方案）
            var commentMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                // Auth相关函数
                {"Login", "用户登录"},
                {"Logout", "用户登出"},
                {"Authenticate", "用户认证"},
                {"ValidateToken", "令牌验证"},
                
                // Session相关函数
                {"CreateSession", "创建会话"},
                {"RemoveSession", "移除会话"},
                {"GetActiveSessions", "获取活跃会话"},
                {"GetActiveUserIds", "获取活跃用户ID"},
                
                // User相关函数
                {"CreateUser", "创建用户"},
                {"UpdateUser", "更新用户"},
                {"DeleteUser", "删除用户"},
                {"GetUser", "获取用户"},
                {"GetAllUsers", "获取所有用户"},
                
                // Permission相关函数
                {"CheckPermission", "检查权限"},
                {"GrantPermission", "授予权限"},
                {"RevokePermission", "撤销权限"},
                
                // System相关函数
                {"GetSystemInfo", "获取系统信息"},
                {"GetCpuUsage", "获取CPU使用率"},
                {"GetMemoryUsage", "获取内存使用率"},
                {"GetDiskInfo", "获取磁盘信息"},
                
                // Log相关函数
                {"WriteLog", "写入日志"},
                {"GetLogs", "获取日志"},
                {"ClearLogs", "清除日志"},
                
                // 通用操作
                {"Create", "创建"},
                {"Update", "更新"},
                {"Delete", "删除"},
                {"Get", "获取"},
                {"Set", "设置"},
                {"Add", "添加"},
                {"Remove", "移除"},
                {"Find", "查找"},
                {"Search", "搜索"},
                {"Validate", "验证"},
                {"Process", "处理"},
                {"Execute", "执行"},
                {"Initialize", "初始化"},
                {"Finalize", "终结"}
            };
            
            // 如果找到对应的中文注释，则返回
            if (commentMap.TryGetValue(functionName, out var comment))
            {
                 return $"({comment})";
            }
            
            // 对于Async函数，尝试查找基础函数名
            if (functionName.EndsWith("Async"))
            {
                var baseName = functionName.Substring(0, functionName.Length - 5);
                if (commentMap.TryGetValue(baseName, out var baseComment))
                {
                    return $"({baseComment}异步)";
                }
            }
            
            // 如果无法找到匹配的注释，返回空字符串
            return "";
        }

        /// <summary>
        /// 获取测试方法的描述信息
        /// </summary>
        private string GetTestDescription(string testName)
        {
            var (description, _, _) = GetTestInfoFromXmlComments(testName);
            return description;
        }

        /// <summary>
        /// 获取测试场景描述
        /// </summary>
        private string GetTestScenario(string testName)
        {
            var (_, scenario, _) = GetTestInfoFromXmlComments(testName);
            return scenario;
        }

        /// <summary>
        /// 获取预期结果描述
        /// </summary>
        private string GetExpectedResult(string testName)
        {
            var (_, _, expectedResult) = GetTestInfoFromXmlComments(testName);
            return expectedResult;
        }

        /// <summary>
        /// 格式化时间，精确到毫秒小数点后7位（不含日期）
        /// </summary>
        private string FormatTimeWithoutDate(string dateTimeString)
        {
            // 尝试解析ISO 8601格式（TRX文件格式）
            if (DateTime.TryParseExact(dateTimeString, "yyyy-MM-ddTHH:mm:ss.fffffffK", 
                System.Globalization.CultureInfo.InvariantCulture, 
                System.Globalization.DateTimeStyles.None, out var dateTime))
            {
                return dateTime.ToString("HH:mm:ss.fffffff");
            }
            
            // 如果ISO格式解析失败，尝试通用解析
            if (DateTime.TryParse(dateTimeString, out dateTime))
            {
                return dateTime.ToString("HH:mm:ss.fffffff");
            }
            
            return dateTimeString;
        }

        /// <summary>
        /// 格式化执行时间，精确到小数点后5位（不含"秒"字）
        /// </summary>
        private string FormatDuration(string duration)
        {
            if (TimeSpan.TryParse(duration, out var timeSpan))
            {
                return timeSpan.TotalSeconds.ToString("F5");
            }
            return duration;
        }

        /// <summary>
        /// 计算实际的时间差（结束时间 - 开始时间）
        /// </summary>
        private string CalculateActualDuration(string startTime, string endTime)
        {
            if (DateTime.TryParseExact(startTime, "yyyy-MM-ddTHH:mm:ss.fffffffK", 
                System.Globalization.CultureInfo.InvariantCulture, 
                System.Globalization.DateTimeStyles.None, out var start) &&
                DateTime.TryParseExact(endTime, "yyyy-MM-ddTHH:mm:ss.fffffffK", 
                System.Globalization.CultureInfo.InvariantCulture, 
                System.Globalization.DateTimeStyles.None, out var end))
            {
                var actualDuration = (end - start).TotalSeconds;
                return actualDuration.ToString("F7");
            }
            
            return "N/A";
        }
    }

    /// <summary>
    /// 测试结果数据类
    /// </summary>
    public class TestResultsData
    {
        public string RunId { get; set; } = "Unknown";
        public string RunName { get; set; } = "Unknown";
        public string StartTime { get; set; } = "Unknown";
        public string FinishTime { get; set; } = "Unknown";
        public int TotalTests { get; set; }
        public int PassedTests { get; set; }
        public int FailedTests { get; set; }
        public int SkippedTests { get; set; }
        public List<TestResult> TestResults { get; set; } = new List<TestResult>();
    }

    /// <summary>
    /// 单个测试结果类
    /// </summary>
    public class TestResult
    {
        public string TestName { get; set; } = "Unknown";
        public string Outcome { get; set; } = "Unknown";
        public string Duration { get; set; } = "Unknown";
        public string StartTime { get; set; } = "Unknown";
        public string EndTime { get; set; } = "Unknown";
    }
}